﻿/* 
* Copyright (c) 2010, The University of Texas at Austin
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, 
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, 
* this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, 
* this list of conditions and the following disclaimer in the documentation and/or other materials 
* provided with the distribution.
*
* Neither the name of The University of Texas at Austin nor the names of its contributors may be 
* used to endorse or promote products derived from this software without specific prior written 
* permission.
* 
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR 
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 
* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

using System;
using System.Windows;
using System.Windows.Media.Imaging;
using Bio.Views.Structure.Editor.Views;
using Bio.Views.ViewModels;
using JulMar.Windows;

namespace Bio.Views.Structure.Editor.ViewModels
{
    public class SecondaryStructureEditorBirdsEyeViewModel : SidebarViewModel<SecondaryStructureBirdsEyeViewer>
    {
        private SecondaryStructureEditorViewModel _editorVM;
        private PropertyObserver<SecondaryStructureEditorViewModel> _editorVMDataChanged;

        private BitmapSource _currentStructureSnapshot;
        public BitmapSource CurrentStructureSnapshot 
        {
            get { return _currentStructureSnapshot; }
            private set
            {
                _currentStructureSnapshot = value;
                OnPropertyChanged("CurrentStructureSnapshot");
            }
        }

        private Size _drawingSize;
        public Size DrawingSize 
        {
            get { return _drawingSize; }
            private set
            {
                _drawingSize = value;
                OnPropertyChanged("DrawingSize");
            }
        }

        private Size _canvasSize;
        public Size CanvasSize
        {
            get { return _canvasSize; }
            private set
            {
                _canvasSize = value;
                OnPropertyChanged("CanvasSize");
            }
        }

        private Point _drawingOffset;
        public Point DrawingOffset
        {
            get { return _drawingOffset; }
            private set
            {
                _drawingOffset = value;
                OnPropertyChanged("DrawingOffset");
            }
        }

        private Size _viewportSize;
        public Size ViewportSize 
        {
            get { return _viewportSize; }
            set
            {
                _viewportSize = value;
                OnPropertyChanged("ViewportSize");
            }
        }
        
        private double _viewportLeft;
        public double ViewportLeft 
        {
            get { return _viewportLeft; }
            set
            {
                _viewportLeft = value;
                OnPropertyChanged("ViewportLeft");
            }
        }

        private double _viewportTop;
        public double ViewportTop 
        {
            get { return _viewportTop; }
            set
            {
                _viewportTop = value;
                OnPropertyChanged("ViewportTop");
            }
        }

        public void UpdateEditorPosition()
        {
            _editorVM.RepositionViewportTo(ViewportLeft, ViewportTop);
        }

        public SecondaryStructureEditorBirdsEyeViewModel(SecondaryStructureEditorViewModel editorVM)
        {
            if (editorVM == null)
                throw new ArgumentException("Parent SecondaryStructureEditorViewModel is null");

            Title = "Birds Eye Viewer";
            ImageUrl = "/Bio.Views.Structure.Editor;component/images/bev_icon.png";
            _editorVM = editorVM;

            InitializeBEV();
            
            _editorVMDataChanged = new PropertyObserver<SecondaryStructureEditorViewModel>(_editorVM);
            //_editorVMDataChanged.RegisterHandler(vm => vm.CurrentViewportLeft, vm => OnEditorVMViewportLeftChanged());
            //_editorVMDataChanged.RegisterHandler(vm => vm.CurrentViewportTop, vm => OnEditorVMViewportTopChanged());
            _editorVMDataChanged.RegisterHandler(vm => vm.CurrentViewportTopLeft, vm => OnEditorVMViewportTopLeftChanged());
            _editorVMDataChanged.RegisterHandler(vm => vm.CurrentViewportSize, vm => OnEditorVMViewportSizeChanged());
            _editorVMDataChanged.RegisterHandler(vm => vm.CurrentDrawingSnapshot, vm => InitializeBEV());
        }

        /*private void OnEditorVMViewportLeftChanged()
        {
            if(ViewportLeft != _editorVM.CurrentViewportLeft)
                ViewportLeft = _editorVM.CurrentViewportLeft;
        }

        private void OnEditorVMViewportTopChanged()
        {
            if (ViewportTop != _editorVM.CurrentViewportTop)
                ViewportTop = _editorVM.CurrentViewportTop;
        }*/

        private void InitializeBEV()
        {
            if (_editorVM != null && _editorVM.CurrentDrawingSnapshot != null)
            {
                CurrentStructureSnapshot = _editorVM.CurrentDrawingSnapshot;
                DrawingSize = _editorVM.CurrentDrawingSize;
                DrawingOffset = _editorVM.CurrentDrawingOffset;
                CanvasSize = _editorVM.CurrentCanvasSize;
                SetInitialFloatingSize();
                //_viewportLeft = _editorVM.CurrentViewportLeft;
                //_viewportTop = _editorVM.CurrentViewportTop;
                _viewportLeft = _editorVM.CurrentViewportTopLeft.X;
                _viewportTop = _editorVM.CurrentViewportTopLeft.Y;
                _viewportSize = _editorVM.CurrentViewportSize;
            }
        }

        private void OnEditorVMViewportTopLeftChanged()
        {
            if (ViewportLeft != _editorVM.CurrentViewportTopLeft.X)
                ViewportLeft = _editorVM.CurrentViewportTopLeft.X;

            if (ViewportTop != _editorVM.CurrentViewportTopLeft.Y)
                ViewportTop = _editorVM.CurrentViewportTopLeft.Y;
        }

        private void OnEditorVMViewportSizeChanged()
        {
            ViewportSize = _editorVM.CurrentViewportSize;
        }

        private void SetInitialFloatingSize()
        {
            //We'll scale it down to 25% of the real canvas size and maintain the aspect ratio.
            double aspectRatio = DrawingSize.Width / DrawingSize.Height;
            double targetHeight = DrawingSize.Height * .25;
            FloatingWindowInitialHeight = targetHeight;
            FloatingWindowInitialWidth = FloatingWindowInitialHeight * aspectRatio;
        }
    }
}
